home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / main / gamemine.c < prev    next >
C/C++ Source or Header  |  1998-08-08  |  28KB  |  870 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: /usr/CVS/descent/main/gamemine.c,v $
  15.  * $Revision: 1.4 $
  16.  * $Author: nobody $
  17.  * $Date: 1998/08/08 15:43:46 $
  18.  * 
  19.  * Functions for loading mines in the game
  20.  * 
  21.  * $Log: gamemine.c,v $
  22.  * Revision 1.4  1998/08/08 15:43:46  nobody
  23.  * Activated the Editior
  24.  *
  25.  * Revision 1.3  1998/04/24 14:27:37  tfrieden
  26.  * Bugfixes (alignment problems)
  27.  *
  28.  * Revision 1.2  1998/03/13 23:51:54  tfrieden
  29.  * various changes with sound, joystick, shareware, notwork
  30.  *
  31.  * Revision 1.1.1.1  1998/03/03 15:12:20  nobody
  32.  * reimport after crash from backup
  33.  *
  34.  * Revision 1.1.1.1  1998/02/13  20:20:44  hfrieden
  35.  * Initial Import
  36.  *
  37.  * Revision 2.2  1995/03/06  15:23:14  john
  38.  * New screen techniques.
  39.  * 
  40.  * Revision 2.1  1995/02/27  13:13:37  john
  41.  * Removed floating point.
  42.  * 
  43.  * Revision 2.0  1995/02/27  11:27:45  john
  44.  * New version 2.0, which has no anonymous unions, builds with
  45.  * Watcom 10.0, and doesn't require parsing BITMAPS.TBL.
  46.  * 
  47.  * Revision 1.70  1995/02/13  20:35:09  john
  48.  * Lintized
  49.  * 
  50.  * Revision 1.69  1995/02/07  17:12:03  rob
  51.  * Added ifdef's for Editor.
  52.  * 
  53.  * Revision 1.68  1995/02/07  16:51:48  mike
  54.  * fix gray rock josh problem.
  55.  * 
  56.  * Revision 1.67  1995/02/01  15:46:26  yuan
  57.  * Fixed matcen_nums.
  58.  * 
  59.  * Revision 1.66  1995/01/19  15:19:28  mike
  60.  * new super-compressed registered file format.
  61.  * 
  62.  * Revision 1.65  1994/12/10  16:44:59  matt
  63.  * Added debugging code to track down door that turns into rock
  64.  * 
  65.  * Revision 1.64  1994/12/10  14:58:24  yuan
  66.  * *** empty log message ***
  67.  * 
  68.  * Revision 1.63  1994/12/08  17:19:10  yuan
  69.  * Cfiling stuff.
  70.  * 
  71.  * Revision 1.62  1994/12/07  14:05:33  yuan
  72.  * Fixed wall assert problem... Bashed highest_segment
  73.  * _index before WALL_IS_DOORWAY check.
  74.  * 
  75.  * Revision 1.61  1994/11/27  23:14:52  matt
  76.  * Made changes for new mprintf calling convention
  77.  * 
  78.  * Revision 1.60  1994/11/27  18:05:20  matt
  79.  * Compile out LVL reader when editor compiled out
  80.  * 
  81.  * Revision 1.59  1994/11/26  22:51:45  matt
  82.  * Removed editor-only fields from segment structure when editor is compiled
  83.  * out, and padded segment structure to even multiple of 4 bytes.
  84.  * 
  85.  * Revision 1.58  1994/11/26  21:48:02  matt
  86.  * Fixed saturation in short light value 
  87.  * 
  88.  * Revision 1.57  1994/11/20  22:11:49  mike
  89.  * comment out an apparently unnecessary call to fuelcen_reset().
  90.  * 
  91.  * Revision 1.56  1994/11/18  21:56:42  john
  92.  * Added a better, leaner pig format.
  93.  * 
  94.  * Revision 1.55  1994/11/17  20:09:18  john
  95.  * Added new compiled level format.
  96.  * 
  97.  * Revision 1.54  1994/11/17  15:40:17  mike
  98.  * Comment out mprintf which was causing important information to scroll away.
  99.  * 
  100.  * Revision 1.53  1994/11/17  14:56:37  mike
  101.  * moved segment validation functions from editor to main.
  102.  * 
  103.  * Revision 1.52  1994/11/17  11:39:35  matt
  104.  * Ripped out code to load old mines
  105.  * 
  106.  * Revision 1.51  1994/11/14  20:47:53  john
  107.  * Attempted to strip out all the code in the game 
  108.  * directory that uses any ui code.
  109.  * 
  110.  * Revision 1.50  1994/11/14  16:05:38  matt
  111.  * Fixed, maybe, again, errors when can't find texture during remap
  112.  * 
  113.  * Revision 1.49  1994/11/14  14:34:03  matt
  114.  * Fixed up handling when textures can't be found during remap
  115.  * 
  116.  * Revision 1.48  1994/11/14  13:01:55  matt
  117.  * Added Int3() when can't find texture
  118.  * 
  119.  * Revision 1.47  1994/10/30  14:12:21  mike
  120.  * rip out local segments stuff.
  121.  * 
  122.  * Revision 1.46  1994/10/27  19:43:07  john
  123.  * Disable the piglet option.
  124.  * 
  125.  * Revision 1.45  1994/10/27  18:51:42  john
  126.  * Added -piglet option that only loads needed textures for a 
  127.  * mine.  Only saved ~1MB, and code still doesn't free textures
  128.  * before you load a new mine.
  129.  * 
  130.  * Revision 1.44  1994/10/20  12:47:22  matt
  131.  * Replace old save files (MIN/SAV/HOT) with new LVL files
  132.  * 
  133.  * Revision 1.43  1994/10/19  16:46:40  matt
  134.  * Made tmap overrides for robots remap texture numbers
  135.  * 
  136.  * Revision 1.42  1994/10/03  23:37:01  mike
  137.  * Adapt to changed fuelcen_activate parameters.
  138.  * 
  139.  * Revision 1.41  1994/09/23  22:14:49  matt
  140.  * Took out obsolete structure fields
  141.  * 
  142.  * Revision 1.40  1994/08/01  11:04:11  yuan
  143.  * New materialization centers.
  144.  * 
  145.  * Revision 1.39  1994/07/21  19:01:47  mike
  146.  * Call Lsegment stuff.
  147.  * 
  148.  * 
  149.  */
  150.  
  151. #pragma off (unreferenced)
  152. static char rcsid[] = "$Id: gamemine.c,v 1.4 1998/08/08 15:43:46 nobody Exp $";
  153. #pragma on (unreferenced)
  154.  
  155. #include <stdio.h>
  156. #include <stdlib.h>
  157. #include <math.h>
  158. #include <string.h>
  159.  
  160. #include "mono.h"
  161.  
  162. #include "inferno.h"
  163. #include "segment.h"
  164. #include "textures.h"
  165. #include "wall.h"
  166. #include "object.h"
  167. #include "gamemine.h"
  168. #include "error.h"
  169. #include "gameseg.h"
  170. #include "switch.h"
  171.  
  172. #include "game.h"
  173. #include "newmenu.h"
  174. #include "byteswap.h"
  175.  
  176. #ifdef EDITOR
  177. #include "editor/editor.h"
  178. #endif
  179.  
  180. #include "cfile.h"      
  181. #include "fuelcen.h"
  182.  
  183. #include "hash.h"
  184. #include "key.h"
  185. #include "piggy.h"
  186.  
  187. #define REMOVE_EXT(s)  (*(strchr( (s), '.' ))='\0')
  188.  
  189. struct mtfi mine_top_fileinfo;    // Should be same as first two fields below...
  190. struct mfi mine_fileinfo;
  191. struct mh mine_header;
  192. struct me mine_editor;
  193.  
  194. int CreateDefaultNewSegment();
  195.  
  196. extern int UseShareware;
  197.  
  198. #ifdef EDITOR
  199.  
  200. static char old_tmap_list[MAX_TEXTURES][13];
  201. short tmap_xlate_table[MAX_TEXTURES];
  202. static short tmap_times_used[MAX_TEXTURES];
  203.  
  204. // -----------------------------------------------------------------------------
  205. //loads from an already-open file
  206. // returns 0=everything ok, 1=old version, -1=error
  207. int load_mine_data(CFILE *LoadFile)
  208. {
  209.     int   i, j;
  210.     short tmap_xlate;
  211.     int     translate;
  212.     char    *temptr;
  213.     int mine_start = cftell(LoadFile);
  214.  
  215.     fuelcen_reset();
  216.  
  217.     for (i=0; i<MAX_TEXTURES; i++ )
  218.         tmap_times_used[i] = 0;
  219.     
  220.     #ifdef EDITOR
  221.     // Create a new mine to initialize things.
  222.     //texpage_goto_first();
  223.     create_new_mine();
  224.     #endif
  225.  
  226.     //===================== READ FILE INFO ========================
  227.  
  228.     // These are the default values... version and fileinfo_sizeof
  229.     // don't have defaults.
  230.     mine_fileinfo.header_offset     =   -1;
  231.     mine_fileinfo.header_size       =   sizeof(mine_header);
  232.     mine_fileinfo.editor_offset     =   -1;
  233.     mine_fileinfo.editor_size       =   sizeof(mine_editor);
  234.     mine_fileinfo.vertex_offset     =   -1;
  235.     mine_fileinfo.vertex_howmany    =   0;
  236.     mine_fileinfo.vertex_sizeof     =   sizeof(vms_vector);
  237.     mine_fileinfo.segment_offset    =   -1;
  238.     mine_fileinfo.segment_howmany   =   0;
  239.     mine_fileinfo.segment_sizeof    =   sizeof(segment);
  240.     mine_fileinfo.newseg_verts_offset     =   -1;
  241.     mine_fileinfo.newseg_verts_howmany    =   0;
  242.     mine_fileinfo.newseg_verts_sizeof     =   sizeof(vms_vector);
  243.     mine_fileinfo.group_offset        = -1;
  244.     mine_fileinfo.group_howmany   = 0;
  245.     mine_fileinfo.group_sizeof        = sizeof(group);
  246.     mine_fileinfo.texture_offset    =   -1;
  247.     mine_fileinfo.texture_howmany   =   0;
  248.     mine_fileinfo.texture_sizeof    =   13;  // num characters in a name
  249.     mine_fileinfo.walls_offset        = -1;
  250.     mine_fileinfo.walls_howmany   = 0;
  251.     mine_fileinfo.walls_sizeof        = sizeof(wall);  
  252.     mine_fileinfo.triggers_offset     = -1;
  253.     mine_fileinfo.triggers_howmany  =   0;
  254.     mine_fileinfo.triggers_sizeof     = sizeof(trigger);  
  255.     mine_fileinfo.object_offset     =   -1;
  256.     mine_fileinfo.object_howmany        =   1;
  257.     mine_fileinfo.object_sizeof     =   sizeof(object);  
  258.  
  259.     // Read in mine_top_fileinfo to get size of saved fileinfo.
  260.     
  261.     memset( &mine_top_fileinfo, 0, sizeof(mine_top_fileinfo) );
  262.  
  263.     if (cfseek( LoadFile, mine_start, SEEK_SET ))
  264.         Error( "Error moving to top of file in gamemine.c" );
  265.  
  266.     if (cfread( &mine_top_fileinfo, sizeof(mine_top_fileinfo), 1, LoadFile )!=1)
  267.         Error( "Error reading mine_top_fileinfo in gamemine.c" );
  268.  
  269.     if (mine_top_fileinfo.fileinfo_signature != 0x2884)
  270.         return -1;
  271.  
  272.     // Check version number
  273.     if (mine_top_fileinfo.fileinfo_version < COMPATIBLE_VERSION )
  274.         return -1;
  275.  
  276.     // Now, Read in the fileinfo
  277.     if (cfseek( LoadFile, mine_start, SEEK_SET ))
  278.         Error( "Error seeking to top of file in gamemine.c" );
  279.  
  280.     if (cfread( &mine_fileinfo, mine_top_fileinfo.fileinfo_sizeof, 1, LoadFile )!=1)
  281.         Error( "Error reading mine_fileinfo in gamemine.c" );
  282.  
  283.     //===================== READ HEADER INFO ========================
  284.  
  285.     // Set default values.
  286.     mine_header.num_vertices        =   0;
  287.     mine_header.num_segments        =   0;
  288.  
  289.     if (mine_fileinfo.header_offset > -1 )
  290.     {
  291.         if (cfseek( LoadFile, mine_fileinfo.header_offset, SEEK_SET ))
  292.             Error( "Error seeking to header_offset in gamemine.c" );
  293.     
  294.         if (cfread( &mine_header, mine_fileinfo.header_size, 1, LoadFile )!=1)
  295.             Error( "Error reading mine_header in gamemine.c" );
  296.     }
  297.  
  298.     //===================== READ EDITOR INFO ==========================
  299.  
  300.     // Set default values
  301.     mine_editor.current_seg         =   0;
  302.     mine_editor.newsegment_offset   =   -1; // To be written
  303.     mine_editor.newsegment_size     =   sizeof(segment);
  304.     mine_editor.Curside             =   0;
  305.     mine_editor.Markedsegp          =   -1;
  306.     mine_editor.Markedside          =   0;
  307.  
  308.     if (mine_fileinfo.editor_offset > -1 )
  309.     {
  310.         if (cfseek( LoadFile, mine_fileinfo.editor_offset, SEEK_SET ))
  311.             Error( "Error seeking to editor_offset in gamemine.c" );
  312.     
  313.         if (cfread( &mine_editor, mine_fileinfo.editor_size, 1, LoadFile )!=1)
  314.             Error( "Error reading mine_editor in gamemine.c" );
  315.     }
  316.  
  317.     //===================== READ TEXTURE INFO ==========================
  318.  
  319.     if ( (mine_fileinfo.texture_offset > -1) && (mine_fileinfo.texture_howmany > 0))
  320.     {
  321.         if (cfseek( LoadFile, mine_fileinfo.texture_offset, SEEK_SET ))
  322.             Error( "Error seeking to texture_offset in gamemine.c" );
  323.  
  324.         for (i=0; i< mine_fileinfo.texture_howmany; i++ )
  325.         {
  326.             if (cfread( &old_tmap_list[i], mine_fileinfo.texture_sizeof, 1, LoadFile )!=1)
  327.                 Error( "Error reading old_tmap_list[i] in gamemine.c" );
  328.         }
  329.     }
  330.  
  331.     //=============== GENERATE TEXTURE TRANSLATION TABLE ===============
  332.  
  333.     translate = 0;
  334.     
  335.     Assert (NumTextures < MAX_TEXTURES);
  336.  
  337.     {
  338.         hashtable ht;
  339.     
  340.         hashtable_init( &ht, NumTextures );
  341.     
  342.         // Remove all the file extensions in the textures list
  343.     
  344.         for (i=0;i<NumTextures;i++) {
  345.             temptr = strchr(TmapInfo[i].filename, '.');
  346.             if (temptr) *temptr = '\0';
  347.             hashtable_insert( &ht, TmapInfo[i].filename, i );
  348.         }
  349.     
  350.         // For every texture, search through the texture list
  351.         // to find a matching name.
  352.         for (j=0;j<mine_fileinfo.texture_howmany;j++)   {
  353.             // Remove this texture name's extension
  354.             temptr = strchr(old_tmap_list[j], '.');
  355.             if (temptr) *temptr = '\0';
  356.     
  357.             tmap_xlate_table[j] = hashtable_search( &ht,old_tmap_list[j]);
  358.             if (tmap_xlate_table[j] < 0 )   {
  359.                 //tmap_xlate_table[j] = 0;
  360.                 // mprintf( (0, "Couldn't find texture '%s'\n", old_tmap_list[j] ));
  361.                 ;
  362.             }
  363.             if (tmap_xlate_table[j] != j ) translate = 1;
  364.             if (tmap_xlate_table[j] >= 0)
  365.                 tmap_times_used[tmap_xlate_table[j]]++;
  366.         }
  367.     
  368.         {
  369.             int count = 0;
  370.             for (i=0; i<MAX_TEXTURES; i++ )
  371.                 if (tmap_times_used[i])
  372.                     count++;
  373.             mprintf( (0, "This mine has %d unique textures in it (~%d KB)\n", count, (count*4096) /1024 ));
  374.         }
  375.     
  376.         mprintf( (0, "Translate=%d\n", translate ));
  377.     
  378.         hashtable_free( &ht );
  379.     }
  380.  
  381.     //====================== READ VERTEX INFO ==========================
  382.  
  383.     // New check added to make sure we don't read in too many vertices.
  384.     if ( mine_fileinfo.vertex_howmany > MAX_VERTICES )
  385.         {
  386.         mprintf((0, "Num vertices exceeds maximum.  Loading MAX %d vertices\n", MAX_VERTICES));
  387.         mine_fileinfo.vertex_howmany = MAX_VERTICES;
  388.         }
  389.  
  390.     if ( (mine_fileinfo.vertex_offset > -1) && (mine_fileinfo.vertex_howmany > 0))
  391.     {
  392.         if (cfseek( LoadFile, mine_fileinfo.vertex_offset, SEEK_SET ))
  393.             Error( "Error seeking to vertex_offset in gamemine.c" );
  394.  
  395.         for (i=0; i< mine_fileinfo.vertex_howmany; i++ )
  396.         {
  397.             // Set the default values for this vertex
  398.             Vertices[i].x = 1;
  399.             Vertices[i].y = 1;
  400.             Vertices[i].z = 1;
  401.  
  402.             if (cfread( &Vertices[i], mine_fileinfo.vertex_sizeof, 1, LoadFile )!=1)
  403.                 Error( "Error reading Vertices[i] in gamemine.c" );
  404.         }
  405.     }
  406.  
  407.     //==================== READ SEGMENT INFO ===========================
  408.  
  409.     // New check added to make sure we don't read in too many segments.
  410.     if ( mine_fileinfo.segment_howmany > MAX_SEGMENTS ) {
  411.         mprintf((0, "Num segments exceeds maximum.  Loading MAX %d segments\n", MAX_SEGMENTS));
  412.         mine_fileinfo.segment_howmany = MAX_SEGMENTS;
  413.     }
  414.  
  415.     // [commented out by mk on 11/20/94 (weren't we supposed to hit final in October?) because it looks redundant.  I think I'll test it now...]  fuelcen_reset();
  416.  
  417.     if ( (mine_fileinfo.segment_offset > -1) && (mine_fileinfo.segment_howmany > 0))    {
  418.  
  419.         if (cfseek( LoadFile, mine_fileinfo.segment_offset,SEEK_SET ))
  420.  
  421.             Error( "Error seeking to segment_offset in gamemine.c" );
  422.  
  423.         Highest_segment_index = mine_fileinfo.segment_howmany-1;
  424.  
  425.         for (i=0; i< mine_fileinfo.segment_howmany; i++ ) {
  426.             segment v16_seg;
  427.  
  428.             // Set the default values for this segment (clear to zero )
  429.             //memset( &Segments[i], 0, sizeof(segment) );
  430.  
  431.             if (mine_top_fileinfo.fileinfo_version >= 16) {
  432.  
  433.                 Assert(mine_fileinfo.segment_sizeof == sizeof(v16_seg));
  434.  
  435.                 if (cfread( &v16_seg, mine_fileinfo.segment_sizeof, 1, LoadFile )!=1)
  436.                     Error( "Error reading segments in gamemine.c" );
  437.  
  438.             }               
  439.             else 
  440.                 Error("Invalid mine version");
  441.  
  442.             Segments[i] = v16_seg;
  443.  
  444.             Segments[i].objects = -1;
  445.             #ifdef EDITOR
  446.             Segments[i].group = -1;
  447.             #endif
  448.  
  449.             if (mine_top_fileinfo.fileinfo_version < 15) {  //used old uvl ranges
  450.                 int sn,uvln;
  451.  
  452.                 for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++)
  453.                     for (uvln=0;uvln<4;uvln++) {
  454.                         Segments[i].sides[sn].uvls[uvln].u /= 64;
  455.                         Segments[i].sides[sn].uvls[uvln].v /= 64;
  456.                         Segments[i].sides[sn].uvls[uvln].l /= 32;
  457.                     }
  458.             }
  459.  
  460.             fuelcen_activate( &Segments[i], Segments[i].special );
  461.  
  462.             if (translate == 1)
  463.                 for (j=0;j<MAX_SIDES_PER_SEGMENT;j++) {
  464.                     unsigned short orient;
  465.                     tmap_xlate = Segments[i].sides[j].tmap_num;
  466.                     Segments[i].sides[j].tmap_num = tmap_xlate_table[tmap_xlate];
  467.                     if ((WALL_IS_DOORWAY(&Segments[i],j) & WID_RENDER_FLAG))
  468.                         if (Segments[i].sides[j].tmap_num < 0)  {
  469.                             mprintf( (0, "Couldn't find texture '%s' for Segment %d, side %d\n", old_tmap_list[tmap_xlate],i,j));
  470.                             Int3();
  471.                             Segments[i].sides[j].tmap_num = 0;
  472.                         }
  473.                     tmap_xlate = Segments[i].sides[j].tmap_num2 & 0x3FFF;
  474.                     orient = Segments[i].sides[j].tmap_num2 & (~0x3FFF);
  475.                     if (tmap_xlate != 0) {
  476.                         int xlated_tmap = tmap_xlate_table[tmap_xlate];
  477.  
  478.                         if ((WALL_IS_DOORWAY(&Segments[i],j) & WID_RENDER_FLAG))
  479.                             if (xlated_tmap <= 0)   {
  480.                                 mprintf( (0, "Couldn't find texture '%s' for Segment %d, side %d\n", old_tmap_list[tmap_xlate],i,j));
  481.                                 Int3();
  482.                                 Segments[i].sides[j].tmap_num2 = 0;
  483.                             }
  484.                         Segments[i].sides[j].tmap_num2 = xlated_tmap | orient;
  485.                     }
  486.                 }
  487.         }
  488.     }
  489.  
  490.     //===================== READ NEWSEGMENT INFO =====================
  491.  
  492.     #ifdef EDITOR
  493.  
  494.     {       // Default segment created.
  495.         vms_vector  sizevec;
  496.         med_create_new_segment(vm_vec_make(&sizevec,DEFAULT_X_SIZE,DEFAULT_Y_SIZE,DEFAULT_Z_SIZE));     // New_segment = Segments[0];
  497.         //memset( &New_segment, 0, sizeof(segment) );
  498.     }
  499.  
  500.     if (mine_editor.newsegment_offset > -1)
  501.     {
  502.         if (cfseek( LoadFile, mine_editor.newsegment_offset,SEEK_SET ))
  503.             Error( "Error seeking to newsegment_offset in gamemine.c" );
  504.         if (cfread( &New_segment, mine_editor.newsegment_size,1,LoadFile )!=1)
  505.             Error( "Error reading new_segment in gamemine.c" );
  506.     }
  507.  
  508.     if ( (mine_fileinfo.newseg_verts_offset > -1) && (mine_fileinfo.newseg_verts_howmany > 0))
  509.     {
  510.         if (cfseek( LoadFile, mine_fileinfo.newseg_verts_offset, SEEK_SET ))
  511.             Error( "Error seeking to newseg_verts_offset in gamemine.c" );
  512.         for (i=0; i< mine_fileinfo.newseg_verts_howmany; i++ )
  513.         {
  514.             // Set the default values for this vertex
  515.             Vertices[NEW_SEGMENT_VERTICES+i].x = 1;
  516.             Vertices[NEW_SEGMENT_VERTICES+i].y = 1;
  517.             Vertices[NEW_SEGMENT_VERTICES+i].z = 1;
  518.             
  519.             if (cfread( &Vertices[NEW_SEGMENT_VERTICES+i], mine_fileinfo.newseg_verts_sizeof,1,LoadFile )!=1)
  520.                 Error( "Error reading Vertices[NEW_SEGMENT_VERTICES+i] in gamemine.c" );
  521.  
  522.             New_segment.verts[i] = NEW_SEGMENT_VERTICES+i;
  523.         }
  524.     }
  525.  
  526.     #endif
  527.                                                             
  528.     //========================= UPDATE VARIABLES ======================
  529.  
  530.     #ifdef EDITOR
  531.  
  532.     // Setting to Markedsegp to NULL ignores Curside and Markedside, which
  533.     // we want to do when reading in an old file.
  534.     
  535.     Markedside = mine_editor.Markedside;
  536.     Curside = mine_editor.Curside;
  537.     for (i=0;i<10;i++)
  538.         Groupside[i] = mine_editor.Groupside[i];
  539.  
  540.     if ( mine_editor.current_seg != -1 )
  541.         Cursegp = mine_editor.current_seg + Segments;
  542.     else
  543.         Cursegp = NULL;
  544.  
  545.     if (mine_editor.Markedsegp != -1 ) 
  546.         Markedsegp = mine_editor.Markedsegp + Segments;
  547.     else
  548.         Markedsegp = NULL;
  549.  
  550.     num_groups = 0;
  551.     current_group = -1;
  552.  
  553.     #endif
  554.  
  555.     Num_vertices = mine_fileinfo.vertex_howmany;
  556.     Num_segments = mine_fileinfo.segment_howmany;
  557.     Highest_vertex_index = Num_vertices-1;
  558.     Highest_segment_index = Num_segments-1;
  559.  
  560.     reset_objects(1);       //one object, the player
  561.  
  562.     #ifdef EDITOR
  563.     Highest_vertex_index = MAX_SEGMENT_VERTICES-1;
  564.     Highest_segment_index = MAX_SEGMENTS-1;
  565.     set_vertex_counts();
  566.     Highest_vertex_index = Num_vertices-1;
  567.     Highest_segment_index = Num_segments-1;
  568.  
  569.     warn_if_concave_segments();
  570.     #endif
  571.  
  572.     #ifdef EDITOR
  573.         validate_segment_all();
  574.     #endif
  575.  
  576.     //create_local_segment_data();
  577.  
  578.     //gamemine_find_textures();
  579.  
  580.     if (mine_top_fileinfo.fileinfo_version < MINE_VERSION )
  581.         return 1;       //old version
  582.     else
  583.         return 0;
  584.  
  585. }
  586. #endif
  587.  
  588. #define COMPILED_MINE_VERSION 0
  589.  
  590. int New_file_format_load = 1;
  591.  
  592. int load_mine_data_compiled(CFILE *LoadFile)
  593. {
  594.     int i,segnum,sidenum;
  595.     ubyte version;
  596.     short temp_short;
  597.     ushort temp_ushort;
  598.  
  599.     if (UseShareware == 0)
  600.         if (New_file_format_load)
  601.             return load_mine_data_compiled_new(LoadFile);
  602.  
  603.     //  For compiled levels, textures map to themselves, prevent tmap_override always being gray,
  604.     //  bug which Matt and John refused to acknowledge, so here is Mike, fixing it.
  605.     //
  606.     // Although in a cloud of arrogant glee, he forgot to ifdef it on EDITOR!
  607.     // (Matt told me to write that!)
  608. #ifdef EDITOR
  609.     for (i=0; i<MAX_TEXTURES; i++)
  610.         tmap_xlate_table[i] = i;
  611. #endif
  612. //  memset( Segments, 0, sizeof(segment)*MAX_SEGMENTS );
  613.     fuelcen_reset();
  614.  
  615.     //=============================== Reading part ==============================
  616.     cfread( &version, sizeof(ubyte), 1, LoadFile );                     // 1 byte = compiled version
  617.     Assert( version==COMPILED_MINE_VERSION );
  618. //  cfread( &Num_vertices, sizeof(int), 1, LoadFile );                  // 4 bytes = Num_vertices
  619.     Num_vertices = read_int_swap(LoadFile);
  620.     Assert( Num_vertices <= MAX_VERTICES );
  621. //  cfread( &Num_segments, sizeof(int), 1, LoadFile );                  // 4 bytes = Num_segments
  622.     Num_segments = read_int_swap(LoadFile);
  623.     Assert( Num_segments <= MAX_SEGMENTS );
  624. //  cfread( Vertices, sizeof(vms_vector), Num_vertices, LoadFile );
  625.  
  626.     for (i = 0; i < Num_vertices; i++) {
  627.         Vertices[i].x = read_fix_swap(LoadFile);
  628.         Vertices[i].y = read_fix_swap(LoadFile);
  629.         Vertices[i].z = read_fix_swap(LoadFile);
  630.     }
  631.  
  632.  
  633.     for (segnum=0; segnum<Num_segments; segnum++ )  {
  634.         #ifdef EDITOR
  635.         Segments[segnum].segnum = segnum;
  636.         Segments[segnum].group = 0;
  637.         #endif
  638.  
  639.         // Read short Segments[segnum].children[MAX_SIDES_PER_SEGMENT]
  640. //      cfread( Segments[segnum].children, sizeof(short), MAX_SIDES_PER_SEGMENT, LoadFile );
  641.         for (i = 0; i < MAX_SIDES_PER_SEGMENT; i++)
  642.             Segments[segnum].children[i] = read_short_swap(LoadFile);
  643.  
  644.  
  645.         // Read short Segments[segnum].verts[MAX_VERTICES_PER_SEGMENT]
  646. //      cfread( Segments[segnum].verts, sizeof(short), MAX_VERTICES_PER_SEGMENT, LoadFile );
  647.         for (i = 0; i < MAX_VERTICES_PER_SEGMENT; i++)
  648.             Segments[segnum].verts[i] = read_short_swap(LoadFile);
  649.  
  650.         Segments[segnum].objects = -1;
  651.  
  652.         // Read ubyte   Segments[segnum].special
  653.         cfread( &Segments[segnum].special, sizeof(ubyte), 1, LoadFile );
  654.         // Read byte    Segments[segnum].matcen_num
  655.         cfread( &Segments[segnum].matcen_num, sizeof(ubyte), 1, LoadFile );
  656.         // Read short   Segments[segnum].value
  657. //      cfread( &Segments[segnum].value, sizeof(short), 1, LoadFile );
  658.         Segments[segnum].value = read_short_swap(LoadFile);
  659.  
  660.         // Read fix Segments[segnum].static_light (shift down 5 bits, write as short)
  661. //      cfread( &temp_ushort, sizeof(temp_ushort), 1, LoadFile );
  662.         temp_ushort = read_short_swap(LoadFile);
  663.         Segments[segnum].static_light   = ((fix)temp_ushort) << 4;
  664.         //cfread( &Segments[segnum].static_light, sizeof(fix), 1, LoadFile );
  665.  
  666.         // Read the walls as a 6 byte array
  667.         for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )  {
  668.             ubyte byte_wallnum;
  669.             Segments[segnum].sides[sidenum].pad = 0;
  670.             cfread( &byte_wallnum, sizeof(ubyte), 1, LoadFile );
  671.             if ( byte_wallnum == 255 )
  672.                 Segments[segnum].sides[sidenum].wall_num = -1;
  673.             else
  674.                 Segments[segnum].sides[sidenum].wall_num = byte_wallnum;
  675.         }
  676.  
  677.         for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )  {
  678.  
  679.             if ( (Segments[segnum].children[sidenum]==-1) || (Segments[segnum].sides[sidenum].wall_num!=-1) )   {
  680.                 // Read short Segments[segnum].sides[sidenum].tmap_num;
  681. //              cfread( &Segments[segnum].sides[sidenum].tmap_num, sizeof(short), 1, LoadFile );
  682.                 Segments[segnum].sides[sidenum].tmap_num = read_short_swap(LoadFile);
  683.                 // Read short Segments[segnum].sides[sidenum].tmap_num2;
  684. //              cfread( &Segments[segnum].sides[sidenum].tmap_num2, sizeof(short), 1, LoadFile );
  685.                 Segments[segnum].sides[sidenum].tmap_num2 = read_short_swap(LoadFile);
  686.                 // Read uvl Segments[segnum].sides[sidenum].uvls[4] (u,v>>5, write as short, l>>1 write as short)
  687.                 for (i=0; i<4; i++ )    {
  688. //                  cfread( &temp_short, sizeof(short), 1, LoadFile );
  689.                     temp_short = read_short_swap(LoadFile);
  690.                     Segments[segnum].sides[sidenum].uvls[i].u = ((fix)temp_short) << 5;
  691. //                  cfread( &temp_short, sizeof(short), 1, LoadFile );
  692.                     temp_short = read_short_swap(LoadFile);
  693.                     Segments[segnum].sides[sidenum].uvls[i].v = ((fix)temp_short) << 5;
  694. //                  cfread( &temp_ushort, sizeof(temp_ushort), 1, LoadFile );
  695.                     temp_ushort = read_short_swap(LoadFile);
  696.                     Segments[segnum].sides[sidenum].uvls[i].l = ((fix)temp_ushort) << 1;
  697. //                  cfread( &Segments[segnum].sides[sidenum].uvls[i].l, sizeof(fix), 1, LoadFile );
  698.                 }
  699.             } else {
  700.                 Segments[segnum].sides[sidenum].tmap_num = 0;
  701.                 Segments[segnum].sides[sidenum].tmap_num2 = 0;
  702.                 for (i=0; i<4; i++ )    {
  703.                     Segments[segnum].sides[sidenum].uvls[i].u = 0;
  704.                     Segments[segnum].sides[sidenum].uvls[i].v = 0;
  705.                     Segments[segnum].sides[sidenum].uvls[i].l = 0;
  706.                 }
  707.             }
  708.         }
  709.     }
  710.  
  711.     Highest_vertex_index = Num_vertices-1;
  712.     Highest_segment_index = Num_segments-1;
  713.  
  714.     validate_segment_all();         // Fill in side type and normals.
  715.  
  716.     // Activate fuelcentes
  717.     for (i=0; i< Num_segments; i++ ) {
  718.         fuelcen_activate( &Segments[i], Segments[i].special );
  719.     }
  720.  
  721.     reset_objects(1);       //one object, the player
  722.  
  723.     return 0;
  724. }
  725.  
  726.  
  727. int load_mine_data_compiled_new(CFILE *LoadFile)
  728. {
  729.     int     i,segnum,sidenum;
  730.     ubyte       version;
  731.     short       temp_short;
  732.     ushort  temp_ushort;
  733.     ubyte       bit_mask;
  734.  
  735.     //  For compiled levels, textures map to themselves, prevent tmap_override always being gray,
  736.     //  bug which Matt and John refused to acknowledge, so here is Mike, fixing it.
  737. #ifdef EDITOR
  738.     for (i=0; i<MAX_TEXTURES; i++)
  739.         tmap_xlate_table[i] = i;
  740. #endif
  741.  
  742. //  memset( Segments, 0, sizeof(segment)*MAX_SEGMENTS );
  743.     fuelcen_reset();
  744.  
  745.     //=============================== Reading part ==============================
  746.     cfread( &version, sizeof(ubyte), 1, LoadFile );                     // 1 byte = compiled version
  747.     Assert( version==COMPILED_MINE_VERSION );
  748.  
  749.     Num_vertices = read_short_swap(LoadFile);
  750.     Assert( Num_vertices <= MAX_VERTICES );
  751.  
  752.     Num_segments = read_short_swap(LoadFile);
  753.     Assert( Num_segments <= MAX_SEGMENTS );
  754.  
  755.     for (i = 0; i < Num_vertices; i++) {
  756.         Vertices[i].x = read_fix_swap(LoadFile);
  757.         Vertices[i].y = read_fix_swap(LoadFile);
  758.         Vertices[i].z = read_fix_swap(LoadFile);
  759.     }
  760.  
  761.     for (segnum=0; segnum<Num_segments; segnum++ )  {
  762.         int bit;
  763.  
  764.         #ifdef EDITOR
  765.         Segments[segnum].segnum = segnum;
  766.         Segments[segnum].group = 0;
  767.         #endif
  768.  
  769.         bit_mask = read_byte(LoadFile);
  770.  
  771.         for (bit=0; bit<MAX_SIDES_PER_SEGMENT; bit++) {
  772.             if (bit_mask & (1 << bit))
  773.                 Segments[segnum].children[bit] = read_short_swap(LoadFile);
  774.             else
  775.                 Segments[segnum].children[bit] = -1;
  776.         }
  777.  
  778.         // Read short Segments[segnum].verts[MAX_VERTICES_PER_SEGMENT]
  779.         for (i = 0; i < MAX_VERTICES_PER_SEGMENT; i++)
  780.             Segments[segnum].verts[i] = read_short_swap(LoadFile);
  781.  
  782.         Segments[segnum].objects = -1;
  783.  
  784.         if (bit_mask & (1 << MAX_SIDES_PER_SEGMENT)) {
  785.             // Read ubyte   Segments[segnum].special
  786.             Segments[segnum].special = read_byte(LoadFile);
  787.             // Read byte    Segments[segnum].matcen_num
  788.             Segments[segnum].matcen_num = read_byte(LoadFile);
  789.             // Read short   Segments[segnum].value
  790.             Segments[segnum].value = read_short_swap(LoadFile);
  791.         } else {
  792.             Segments[segnum].special = 0;
  793.             Segments[segnum].matcen_num = -1;
  794.             Segments[segnum].value = 0;
  795.         }
  796.  
  797.         // Read fix Segments[segnum].static_light (shift down 5 bits, write as short)
  798.         temp_ushort = read_short_swap(LoadFile);
  799.         Segments[segnum].static_light   = ((fix)temp_ushort) << 4;
  800.  
  801.         // Read the walls as a 6 byte array
  802.         for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )  {
  803.             Segments[segnum].sides[sidenum].pad = 0;
  804.         }
  805.  
  806.         bit_mask = read_byte(LoadFile);
  807.         for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++) {
  808.             ubyte byte_wallnum;
  809.  
  810.             if (bit_mask & (1 << sidenum)) {
  811.                 byte_wallnum = read_byte(LoadFile);
  812.                 if ( byte_wallnum == 255 )
  813.                     Segments[segnum].sides[sidenum].wall_num = -1;
  814.                 else
  815.                     Segments[segnum].sides[sidenum].wall_num = byte_wallnum;
  816.             } else
  817.                     Segments[segnum].sides[sidenum].wall_num = -1;
  818.         }
  819.  
  820.         for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )  {
  821.  
  822.             if ( (Segments[segnum].children[sidenum]==-1) || (Segments[segnum].sides[sidenum].wall_num!=-1) )   {
  823.                 // Read short Segments[segnum].sides[sidenum].tmap_num;
  824.                 temp_ushort = read_short_swap(LoadFile);
  825.                 Segments[segnum].sides[sidenum].tmap_num = temp_ushort & 0x7fff;
  826.  
  827.                 if (!(temp_ushort & 0x8000))
  828.                     Segments[segnum].sides[sidenum].tmap_num2 = 0;
  829.                 else {
  830.                     // Read short Segments[segnum].sides[sidenum].tmap_num2;
  831.                     Segments[segnum].sides[sidenum].tmap_num2 = read_short_swap(LoadFile);
  832.                 }
  833.  
  834.                 // Read uvl Segments[segnum].sides[sidenum].uvls[4] (u,v>>5, write as short, l>>1 write as short)
  835.                 for (i=0; i<4; i++ )    {
  836.                     temp_short = read_short_swap(LoadFile);
  837.                     Segments[segnum].sides[sidenum].uvls[i].u = ((fix)temp_short) << 5;
  838.                     temp_short = read_short_swap(LoadFile);
  839.                     Segments[segnum].sides[sidenum].uvls[i].v = ((fix)temp_short) << 5;
  840.                     temp_ushort = read_short_swap(LoadFile);
  841.                     Segments[segnum].sides[sidenum].uvls[i].l = ((fix)temp_ushort) << 1;
  842.                 }
  843.             } else {
  844.                 Segments[segnum].sides[sidenum].tmap_num = 0;
  845.                 Segments[segnum].sides[sidenum].tmap_num2 = 0;
  846.                 for (i=0; i<4; i++ )    {
  847.                     Segments[segnum].sides[sidenum].uvls[i].u = 0;
  848.                     Segments[segnum].sides[sidenum].uvls[i].v = 0;
  849.                     Segments[segnum].sides[sidenum].uvls[i].l = 0;
  850.                 }
  851.             }
  852.         }
  853.     }
  854.  
  855.     Highest_vertex_index = Num_vertices-1;
  856.     Highest_segment_index = Num_segments-1;
  857.  
  858.     validate_segment_all();         // Fill in side type and normals.
  859.  
  860.     // Activate fuelcentes
  861.     for (i=0; i< Num_segments; i++ ) {
  862.         fuelcen_activate( &Segments[i], Segments[i].special );
  863.     }
  864.  
  865.     reset_objects(1);       //one object, the player
  866.  
  867.     return 0;
  868. }
  869.  
  870.